The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section.
Tracing is a form of computer logging through which information about a software application's execution is recorded. The messages recorded in a trace log typically capture low-level information that may be used by software developers, system administrators, and other personnel to troubleshoot problems that occur at runtime. For example, a trace logging message written to a trace log may indicate a state of the software program's execution at the time of the call or other runtime information that may be useful for debugging problems that may arise during the software application's execution.
To enable trace logging by a software application, the source code of the application may be instrumented with trace logging calls to a trace logging module. When the code or a compiled version thereof is executed by a computer system, the trace logging calls cause trace logging messages to be written to a trace log, where they may be subsequently accessed and analyzed. Typically, the trace logging calls capture execution information at a fine level of detail to help diagnose and isolate the root cause of a problem. For example, trace logs may pass information about variables, fields, values, or states (“information”) of the software as they existed at the time of the call, and in an execution context that was available to/exposed to/within the execution scope of the call. Different calls may expose different such information based on the different execution contexts or scopes in which the different calls were executed. The information may also vary over time depending on the functionality for which the code is operating or subject data on which the code is operating at a given time. Capturing trace messages at the finest possible level of detail typically results in huge amounts of trace data being generated, which may increase the storage footprint of the trace log and degrade performance of the software application and the host machine(s) on which the software application is executing.
In order to mitigate the impact of performance degradation caused by trace logging operations, one approach is to implement an adaptive trace logging module that automatically changes the trace logging level of the executing software application based on detected runtime conditions. In a normal operating state, a trace logging module may capture information at a higher level of detail to reduce the overhead of trace logging operations. If an abnormal condition is detected, then the adaptive trace logging module may increase the trace logging level to capture information at a finer level of detail and help diagnose any issues that caused the abnormal condition. An example of an adaptive trace logging module is described in U.S. patent applicaton Ser. No. 12/559,338, entitled “Techniques for Adaptive Trace Logging”, the entire contents of which are incorporated by reference herein as if set forth in their entirety.
Adaptive trace logging modules increase the level of trace messages in scenarios where it may be acceptable from a system performance standpoint to generate additional finer trace level data. However, much of the finer-level details that are captured may be irrelevant to the problem at hand. As a result, though some of the finer-level details may be helpful in isolating and resolving the problem, technical personnel may still need to sift through vast amounts of trace data in an effort to identify the data that is relevant. This may cause delay in resolving defects or other issues in a software application, the negative impact of which becomes particularly acute within production and mission-critical systems.